4001 (Normal User)
Newbie
Messaggi: 2
Iscritto: 03/04/2012
|
Buongiorno a tutti, sono nuovo del forum!
Dopo ricerche di tutti i tipi mi rivolgo a voi sperando di trovare qualcuno che mi faccia capire dove sbaglio.
Per un progetto devo creare un programma MIPS che crei delle matrici quadrate di numeri interi (10x10 max) e ne calcoli il prodotto scalare di ciascun elemento, mettendo poi i risultati in una terza matrice.
Ora, le due matrici riesco a crearle senza, credo, problemi.
I problemi nascono quando devo moltiplicare i singoli elementi e metterli nella terza matrice (che dovrei anche stampare per capire che almeno sto facendo giusto).
Per l'uso dei registri: Ho usato $s0 per memorizzare il "lato" di ogni matrice, in modo da immetterlo da input ed averlo uguale per tutte le matrici. Idem per i due registri $t2, $t3 che utilizzo come indici i e j per scorrere le matrici.
Una nota. Sono sicuro di aver fatto confusione con i registri e a questo punto mi risulta difficile uscire da questo casino. Spero che un occhio esterno veda dove sto sbagliando, perchè comincio a non capirci più nulla. Il MIPS lo sto studiando da poco e sebbene sia affascinante mi sta provocando gran mal di testa..
vi allego il codice, spero di non essere stato troppo prolisso ma abbastanza dettagliato. se avete domande chiedete pure. Grazie a chi vorrà/potrà aiutarmi.
Codice sorgente - presumibilmente Plain Text |
.data
string1: .asciiz "\ninserisci un numero che andrà nella riga "
string2: .asciiz "\ne nella colonna "
string3: .asciiz "\ninserisci un valore per il lato della matrice quadrata compreso tra 1 e 10: "
string4: .asciiz "\ninserisci un valore nella seconda matrice-operando nella riga : "
string5: .asciiz "\ne nella colonna "
capo: .asciiz "\n"
M: .word 0:100
M1: .word 0:100
M2: .word 0:100
.text
.globl main
main: #lettura
li $v0, 4
la $a0, string3
syscall
li $v0, 5
syscall
#qui va messo un controllo per avere 1 < N < 10
add $s0, $v0, $zero
li $t2, 0 #indice riga
li $t3, 0 #indice colonna
la $s1, M #indirizzo iniziale matrice M
cicloR: bge $t2, $s0, MAT1 #se l'indice riga è più grande del limite
cicloC: bge $t3, $s0, fineC #se l'indice colonna è più grande del limite
#stampo riga
li $v0, 4
la $a0, string1
syscall
li $v0, 1
add $a0, $t2, $zero
syscall
#stampo colonna
li $v0, 4
la $a0, string2
syscall
li $v0, 1
add $a0 $t3, $zero
syscall
#a capo
li $v0, 4
la $a0, capo
syscall
#leggo il numero
li $v0, 5
syscall
add $s7, $v0, $zero
j incremento
incremento:
lw $s7, 0($s1)
#stampa a video il numero in posizione
#li $v0, 1
#add $a0, $s7, $zero
#syscall
#invio
li $v0, 4
la $a0, capo
syscall
addi $t4, $s1, 4 #scorre le righe con incrementi di 4
addi $t3, $t3, 1 #scorre le colonne con incrementi di 1
j cicloC
fineC: li $t3, 0
addi $t2, $t2, 1
j cicloR
#####################################################################
MAT1: #add $s0, $v0, $zero
li $t2, 0 #indice riga
li $t3, 0 #indice colonna
la $s2, M1 #indirizzo iniziale matrice M1
li $t2, 0 #riazzera gli indici
li $t3, 0 #riazzera gli indici
cicloR1: bge $t2, $s0, MAT2 #se l'indice riga è più grande del limite
cicloC1: bge $t3, $s0, fineC1 #se l'indice colonna è più grande del limite
#stampo riga
li $v0, 4
la $a0, string4
syscall
li $v0, 1
add $a0, $t2, $zero
syscall
#stampo colonna
li $v0, 4
la $a0, string5
syscall
li $v0, 1
add $a0 $t3, $zero
syscall
#a capo
li $v0, 4
la $a0, capo
syscall
#leggo il numero
li $v0, 5
syscall
add $s5, $v0, $zero
j incremento1
incremento1:
lw $s5, 0($s2)
#li $v0, 1
#add $a0, $s5, $zero
#syscall
li $v0, 4
la $a0, capo
syscall
addi $t0, $t0, 4
addi $t3, $t3, 1
j cicloC1
fineC1:
li $t3, 0
addi $t2, $t2, 1
j cicloR1
##########
# matrice risultati
MAT2: #add $s0, $v0, $zero
li $t2, 0 #indice riga
li $t3, 0 #indice colonna
la $t0, M2 #indirizzo iniziale matrice M2
li $t2, 0 #riazzera gli indici
li $t3, 0 #riazzera gli indici
add $t1, $zero, $zero
ciclo:
cicloR2: bge $t2, $s0, fineR2 #se l'indice riga è più grande del limite
cicloC2: bge $t3, $s0, fineC2 #se l'indice colonna è più grande del limite
sub $s4, $s0, 1
mul $s8, $s0, $s0
#prodotto scalare
mul $t6, $s7, $s5
li $v0, 1
move $a0, $t6
syscall
#a capo
li $v0, 4
la $a0, capo
syscall
#add $t6, $a0, $t6
#addi $s7, $s7, 4
#addi $s5, $s5, 4
addi $t1, $t1, 1
bne $t1, $s4, ciclo
j fineR2
incremento2:
li $v0, 1
add $a0, $t6, $zero
syscall
li $v0, 4
la $a0, capo
syscall
addi $t0, $t0, 4
addi $t3, $t3, 1
j cicloC2
fineC2:
li $t3, 0
addi $t2, $t2, 1
j cicloR2
###########
fineR2:
li $v0, 10
syscall
|
|
![Altri Linguaggi - [MIPS] Calcolo del prodotto scalare tra due matrici](/data/logos/logositov9.png)
